#else
XNextEvent (gdk_display, &xevent);
#endif
+
+ switch (xevent.type)
+ {
+ case KeyPress:
+ case KeyRelease:
+ break;
+ default:
+ if (XFilterEvent (&xevent, None))
+ continue;
+ }
event = gdk_event_new ();
INCLUDES = @STRIP_BEGIN@ \
-DG_LOG_DOMAIN=\"Gtk\" \
-DGTK_DISABLE_COMPAT_H \
- -DGTK_EXE_PREFIX=\"$(exec_prefix)\" \
+ -DGTK_LIBDIR=\"$(libdir)\" \
-DGTK_DATA_PREFIX=\"$(prefix)\" \
-DGTK_SYSCONFDIR=\"$(sysconfdir)\" \
-DGTK_LOCALEDIR=\"$(gtklocaledir)\" \
gtkcolorsel.h \
gtkcolorseldialog.h \
gtkcombo.h \
- gtkcompat.h \
gtkcontainer.h \
gtkctree.h \
gtkcurve.h \
#
# setup GTK+ sources and their dependancies
#
-gtk_target_headers = $(gtk_public_h_sources) $(gtk_built_public_sources)
+gtk_target_headers = $(gtk_public_h_sources) $(gtk_built_public_sources) gtkcompat.h
gtk_target_sources = $(gtk_c_sources)
MAINTAINERCLEANFILES += $(gtk_built_sources)
EXTRA_HEADERS +=
GdkBitmap *mask)
{
GtkRequisition requisition;
-
+ gchar *old_text = NULL;
+ GdkPixmap *old_pixmap = NULL;
+ GdkBitmap *old_mask = NULL;
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
g_return_if_fail (clist_row != NULL);
case GTK_CELL_EMPTY:
break;
case GTK_CELL_TEXT:
- g_free (GTK_CELL_TEXT (clist_row->cell[column])->text);
+ old_text = GTK_CELL_TEXT (clist_row->cell[column])->text;
break;
case GTK_CELL_PIXMAP:
- gdk_pixmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap);
- if (GTK_CELL_PIXMAP (clist_row->cell[column])->mask)
- gdk_bitmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->mask);
+ old_pixmap = GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap;
+ old_mask = GTK_CELL_PIXMAP (clist_row->cell[column])->mask;
break;
case GTK_CELL_PIXTEXT:
- g_free (GTK_CELL_PIXTEXT (clist_row->cell[column])->text);
- gdk_pixmap_unref (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap);
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask)
- gdk_bitmap_unref (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask);
+ old_text = GTK_CELL_PIXTEXT (clist_row->cell[column])->text;
+ old_pixmap = GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap;
+ old_mask = GTK_CELL_PIXTEXT (clist_row->cell[column])->mask;
break;
case GTK_CELL_WIDGET:
/* unimplimented */
clist_row->cell[column].type = GTK_CELL_EMPTY;
+ /* Note that pixmap and mask were already ref'ed by the caller
+ */
switch (type)
{
case GTK_CELL_TEXT:
if (clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
column_auto_resize (clist, clist_row, column, requisition.width);
+
+ if (old_text)
+ g_free (old_text);
+ if (old_pixmap)
+ gdk_pixmap_unref (old_pixmap);
+ if (old_mask)
+ gdk_pixmap_unref (old_mask);
}
PangoLayout *
#define COMBO_LIST_MAX_HEIGHT (400)
#define EMPTY_LIST_HEIGHT (15)
-static void gtk_combo_class_init (GtkComboClass *klass);
-static void gtk_combo_init (GtkCombo *combo);
-static void gtk_combo_destroy (GtkObject *combo);
-static GtkListItem *gtk_combo_find (GtkCombo *combo);
-static gchar * gtk_combo_func (GtkListItem *li);
-static gint gtk_combo_focus_idle (GtkCombo *combo);
-static gint gtk_combo_entry_focus_out (GtkEntry *entry,
- GdkEventFocus *event,
- GtkCombo *combo);
-static void gtk_combo_get_pos (GtkCombo *combo,
- gint *x,
- gint *y,
- gint *height,
- gint *width);
-static void gtk_combo_popup_list (GtkCombo *combo);
-static void gtk_combo_activate (GtkWidget *widget,
- GtkCombo *combo);
+static void gtk_combo_class_init (GtkComboClass *klass);
+static void gtk_combo_init (GtkCombo *combo);
+static void gtk_combo_destroy (GtkObject *combo);
+static GtkListItem *gtk_combo_find (GtkCombo *combo);
+static gchar * gtk_combo_func (GtkListItem *li);
+static gint gtk_combo_focus_idle (GtkCombo *combo);
+static gint gtk_combo_entry_focus_out (GtkEntry *entry,
+ GdkEventFocus *event,
+ GtkCombo *combo);
+static void gtk_combo_get_pos (GtkCombo *combo,
+ gint *x,
+ gint *y,
+ gint *height,
+ gint *width);
+static void gtk_combo_popup_list (GtkCombo *combo);
+static void gtk_combo_activate (GtkWidget *widget,
+ GtkCombo *combo);
static void gtk_combo_popup_button_press (GtkWidget *button,
GdkEventButton *event,
GtkCombo *combo);
static void gtk_combo_popup_button_leave (GtkWidget *button,
GdkEventCrossing *event,
GtkCombo *combo);
-static void gtk_combo_update_entry (GtkList *list,
- GtkCombo *combo);
-static void gtk_combo_update_list (GtkEntry *entry,
- GtkCombo *combo);
-static gint gtk_combo_button_press (GtkWidget *widget,
- GdkEvent *event,
- GtkCombo *combo);
-static gint gtk_combo_button_release (GtkWidget *widget,
- GdkEvent *event,
- GtkCombo *combo);
-static gint gtk_combo_list_enter (GtkWidget *widget,
- GdkEventCrossing *event,
- GtkCombo *combo);
-static gint gtk_combo_list_key_press (GtkWidget *widget,
- GdkEventKey *event,
- GtkCombo *combo);
-static gint gtk_combo_entry_key_press (GtkEntry *widget,
- GdkEventKey *event,
- GtkCombo *combo);
-static void gtk_combo_item_destroy (GtkObject *object);
-static void gtk_combo_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation);
+static void gtk_combo_update_entry (GtkList *list,
+ GtkCombo *combo);
+static void gtk_combo_update_list (GtkEntry *entry,
+ GtkCombo *combo);
+static gint gtk_combo_button_press (GtkWidget *widget,
+ GdkEvent *event,
+ GtkCombo *combo);
+static gint gtk_combo_button_release (GtkWidget *widget,
+ GdkEvent *event,
+ GtkCombo *combo);
+static gint gtk_combo_list_enter (GtkWidget *widget,
+ GdkEventCrossing *event,
+ GtkCombo *combo);
+static gint gtk_combo_list_key_press (GtkWidget *widget,
+ GdkEventKey *event,
+ GtkCombo *combo);
+static gint gtk_combo_entry_key_press (GtkEntry *widget,
+ GdkEventKey *event,
+ GtkCombo *combo);
+static gint gtk_combo_window_key_press (GtkWidget *window,
+ GdkEventKey *event,
+ GtkCombo *combo);
+static void gtk_combo_item_destroy (GtkObject *object);
+static void gtk_combo_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation);
static GtkHBoxClass *parent_class = NULL;
return FALSE;
}
+static int
+gtk_combo_window_key_press (GtkWidget *window,
+ GdkEventKey *event,
+ GtkCombo *combo)
+{
+ GList *li;
+
+ if (event->keyval == GDK_Return || event->keyval == GDK_KP_Enter)
+ {
+ if (GTK_WIDGET_VISIBLE (combo->popwin))
+ {
+ gtk_widget_hide (combo->popwin);
+
+ if (GTK_WIDGET_HAS_GRAB (combo->popwin))
+ {
+ gtk_grab_remove (combo->popwin);
+ gdk_pointer_ungrab (event->time);
+ }
+ }
+
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (window), "key_press_event");
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
static GtkListItem *
gtk_combo_find (GtkCombo * combo)
{
combo->popwin = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_ref (combo->popwin);
gtk_window_set_policy (GTK_WINDOW (combo->popwin), 1, 1, 0);
+
+ gtk_signal_connect (GTK_OBJECT (combo->popwin), "key_press_event",
+ GTK_SIGNAL_FUNC (gtk_combo_window_key_press), combo);
gtk_widget_set_events (combo->popwin, GDK_KEY_PRESS_MASK);
gtk_clist_freeze (clist);
work = NULL;
- if (gtk_ctree_is_viewable (ctree, node) ||
- gtk_ctree_is_viewable (ctree, new_sibling))
+ if (gtk_ctree_is_viewable (ctree, node))
work = GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
gtk_ctree_unlink (ctree, node, FALSE);
gboolean visible = FALSE;
GtkCTree *ctree;
GtkRequisition requisition;
+ gchar *old_text = NULL;
+ GdkPixmap *old_pixmap = NULL;
+ GdkBitmap *old_mask = NULL;
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
{
case GTK_CELL_EMPTY:
break;
-
case GTK_CELL_TEXT:
- g_free (GTK_CELL_TEXT (clist_row->cell[column])->text);
+ old_text = GTK_CELL_TEXT (clist_row->cell[column])->text;
break;
case GTK_CELL_PIXMAP:
- gdk_pixmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap);
- if (GTK_CELL_PIXMAP (clist_row->cell[column])->mask)
- gdk_bitmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->mask);
+ old_pixmap = GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap;
+ old_mask = GTK_CELL_PIXMAP (clist_row->cell[column])->mask;
break;
case GTK_CELL_PIXTEXT:
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->text)
- g_free (GTK_CELL_PIXTEXT (clist_row->cell[column])->text);
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap)
- {
- gdk_pixmap_unref
- (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap);
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask)
- gdk_bitmap_unref
- (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask);
- }
+ old_text = GTK_CELL_PIXTEXT (clist_row->cell[column])->text;
+ old_pixmap = GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap;
+ old_mask = GTK_CELL_PIXTEXT (clist_row->cell[column])->mask;
break;
case GTK_CELL_WIDGET:
/* unimplimented */
if (column == ctree->tree_column && type != GTK_CELL_EMPTY)
type = GTK_CELL_PIXTEXT;
+ /* Note that pixmap and mask were already ref'ed by the caller
+ */
switch (type)
{
case GTK_CELL_TEXT:
if (visible && clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
column_auto_resize (clist, clist_row, column, requisition.width);
+
+ if (old_text)
+ g_free (old_text);
+ if (old_pixmap)
+ gdk_pixmap_unref (old_pixmap);
+ if (old_mask)
+ gdk_pixmap_unref (old_mask);
}
static void
GtkEditable *editable = GTK_EDITABLE (entry);
gint tmp_pos = entry->current_pos;
+ gtk_editable_delete_selection (editable);
+
gtk_editable_insert_text (editable, str, strlen (str), &tmp_pos);
gtk_editable_set_position (editable, tmp_pos);
}
#define FILE_LIST_WIDTH 180
#define FILE_LIST_HEIGHT 180
+/* The Hurd doesn't define either PATH_MAX or MAXPATHLEN, so we put this
+ * in here, since the rest of the code in the file does require some
+ * fixed maximum.
+ */
+#ifndef MAXPATHLEN
+# ifdef PATH_MAX
+# define MAXPATHLEN PATH_MAX
+# else
+# define MAXPATHLEN 2048
+# endif
+#endif
+
/* I've put this here so it doesn't get confused with the
* file completion interface */
typedef struct _HistoryCallbackArg HistoryCallbackArg;
static GtkBinClass *parent_class = NULL;
-/* Here until I convince timj about memory management behavior
- */
-gchar * gtk_frame_get_label (GtkFrame *frame);
-gchar * gtk_label_get_text (GtkLabel *label);
-
-
GtkType
gtk_frame_get_type (void)
{
* was no label widget or the lable widget was not
* a #GtkLabel. This value must be freed with g_free().
**/
-gchar *
+G_CONST_RETURN gchar *
gtk_frame_get_label (GtkFrame *frame)
{
g_return_val_if_fail (frame != NULL, NULL);
GtkType gtk_frame_get_type (void) G_GNUC_CONST;
GtkWidget* gtk_frame_new (const gchar *label);
-void gtk_frame_set_label (GtkFrame *frame,
- const gchar *label);
-/* Temporarily commented out until memory management behavior is figured out */
-/* gchar * gtk_frame_get_label (GtkFrame *frame); */
+
+void gtk_frame_set_label (GtkFrame *frame,
+ const gchar *label);
+G_CONST_RETURN gchar *gtk_frame_get_label (GtkFrame *frame);
+
void gtk_frame_set_label_widget (GtkFrame *frame,
GtkWidget *label_widget);
void gtk_frame_set_label_align (GtkFrame *frame,
GtkStyle *previous_style)
{
GtkHandleBox *hb;
+ GdkRectangle new_area;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HANDLE_BOX (widget));
return FALSE;
child = GTK_BIN (hb)->child;
-
- switch (hb->handle_position)
+
+ if (child)
{
- case GTK_POS_LEFT:
- in_handle = event->x < DRAG_HANDLE_SIZE;
- break;
- case GTK_POS_TOP:
- in_handle = event->y < DRAG_HANDLE_SIZE;
- break;
- case GTK_POS_RIGHT:
- in_handle = event->x > 2 * GTK_CONTAINER (hb)->border_width + child->allocation.width;
- break;
- case GTK_POS_BOTTOM:
- in_handle = event->y > 2 * GTK_CONTAINER (hb)->border_width + child->allocation.height;
- break;
- default:
- in_handle = FALSE;
- break;
+ switch (hb->handle_position)
+ {
+ case GTK_POS_LEFT:
+ in_handle = event->x < DRAG_HANDLE_SIZE;
+ break;
+ case GTK_POS_TOP:
+ in_handle = event->y < DRAG_HANDLE_SIZE;
+ break;
+ case GTK_POS_RIGHT:
+ in_handle = event->x > 2 * GTK_CONTAINER (hb)->border_width + child->allocation.width;
+ break;
+ case GTK_POS_BOTTOM:
+ in_handle = event->y > 2 * GTK_CONTAINER (hb)->border_width + child->allocation.height;
+ break;
+ default:
+ in_handle = FALSE;
+ break;
+ }
}
-
- if (!child)
+ else
{
in_handle = FALSE;
event_handled = TRUE;
const gchar *path)
{
GtkItemFactoryClass *class;
- GtkItemFactoryItem *item;
- gchar *fpath;
+ GtkWidget *widget;
g_return_if_fail (ifactory != NULL);
g_return_if_fail (GTK_IS_ITEM_FACTORY (ifactory));
class = GTK_ITEM_FACTORY_GET_CLASS (ifactory);
- fpath = g_strconcat (ifactory->path, path, NULL);
- item = g_hash_table_lookup (class->item_ht, fpath);
- g_free (fpath);
+ widget = gtk_item_factory_get_widget (ifactory, path);
- if (item)
+ if (widget)
{
- GtkWidget *widget = NULL;
- GSList *slist;
-
- for (slist = item->widgets; slist; slist = slist->next)
- {
- widget = slist->data;
-
- if (gtk_item_factory_from_widget (widget) == ifactory)
- break;
- }
+ if (GTK_IS_MENU (widget))
+ widget = gtk_menu_get_attach_widget (GTK_MENU (widget));
- if (slist)
- gtk_widget_destroy (widget);
+ gtk_widget_destroy (widget);
}
}
* Return value: the text in the label widget. This value must
* be freed with g_free().
**/
-gchar *
+G_CONST_RETURN gchar *
gtk_label_get_text (GtkLabel *label)
{
g_return_val_if_fail (label != NULL, NULL);
g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
- return g_strdup (label->label);
+ return label->label;
}
void
GtkType gtk_label_get_type (void) G_GNUC_CONST;
GtkWidget *gtk_label_new (const char *str);
-void gtk_label_set_text (GtkLabel *label,
- const char *str);
+
+void gtk_label_set_text (GtkLabel *label,
+ const char *str);
+G_CONST_RETURN gchar *gtk_label_get_text (GtkLabel *label);
+
void gtk_label_set_attributes (GtkLabel *label,
PangoAttrList *attrs);
guint gtk_label_set_markup_with_accel (GtkLabel *label,
const gchar *str);
-
-/* Temporarily commented out until memory management behavior is figured out *//* gchar * gtk_label_get_text (GtkLabel *label); */
void gtk_label_set_justify (GtkLabel *label,
GtkJustification jtype);
void gtk_label_set_pattern (GtkLabel *label,
g_return_if_fail (list != NULL);
g_return_if_fail (GTK_IS_LIST (list));
+ if ((list->selection_mode == GTK_SELECTION_BROWSE ||
+ list->selection_mode == GTK_SELECTION_EXTENDED) &&
+ GTK_WIDGET (list_item)->state == GTK_STATE_NORMAL)
+ {
+ gtk_widget_set_state (GTK_WIDGET (list_item), GTK_STATE_SELECTED);
+ return;
+ }
+
switch (GTK_WIDGET (list_item)->state)
{
case GTK_STATE_SELECTED:
static void gtk_menu_reparent (GtkMenu *menu,
GtkWidget *new_parent,
gboolean unrealize);
+static void gtk_menu_remove (GtkContainer *menu,
+ GtkWidget *widget);
static GtkMenuShellClass *parent_class = NULL;
static const gchar *attach_data_key = "gtk-menu-attach-data";
widget_class->hide_all = gtk_menu_hide_all;
widget_class->enter_notify_event = gtk_menu_enter_notify;
widget_class->leave_notify_event = gtk_menu_leave_notify;
+
+ container_class->remove = gtk_menu_remove;
menu_shell_class->submenu_placement = GTK_LEFT_RIGHT;
menu_shell_class->deactivate = gtk_menu_deactivate;
gtk_widget_unref (GTK_WIDGET (menu));
}
+void
+gtk_menu_remove(GtkContainer *container,
+ GtkWidget *widget)
+{
+ GtkMenu *menu;
+ g_return_if_fail (GTK_IS_MENU (container));
+ g_return_if_fail (GTK_IS_MENU_ITEM (widget));
+
+ menu = GTK_MENU (container);
+
+ /* Clear out old_active_menu_item if it matches the item we are removing
+ */
+ if (menu->old_active_menu_item == widget)
+ {
+ gtk_widget_unref (menu->old_active_menu_item);
+ menu->old_active_menu_item = NULL;
+ }
+
+ GTK_CONTAINER_CLASS (parent_class)->remove (container, widget);
+}
+
+
GtkWidget*
gtk_menu_new (void)
{
menu_shell = GTK_MENU_SHELL (container);
menu_shell->children = g_list_remove (menu_shell->children, widget);
+ if (widget == menu_shell->active_menu_item)
+ {
+ gtk_item_deselect (GTK_ITEM (menu_shell->active_menu_item));
+ menu_shell->active_menu_item = NULL;
+ }
+
gtk_widget_unparent (widget);
/* queue resize regardless of GTK_WIDGET_VISIBLE (container),
}
gdk_draw_rectangle(pm, pmgc, TRUE, x, y, width, height);
- /* if theres an area for scrollign arrows draw the shape for them */
- if (notebook->panel)
+ /* if theres an area for scrolling arrows draw the shape for them */
+ if (notebook->panel && gdk_window_is_visible (notebook->panel))
{
gdk_window_get_geometry(notebook->panel, &x, &y, &width, &height, &depth);
gdk_draw_rectangle(pm, pmgc, TRUE, x, y, width, height);
g_signal_emit (G_OBJECT (option_menu), signals[CHANGED], 0);
}
+static void
+gtk_option_menu_select_first_sensitive (GtkOptionMenu *option_menu)
+{
+ if (option_menu->menu)
+ {
+ GList *children = GTK_MENU_SHELL (option_menu->menu)->children;
+ gint index = 0;
+
+ while (children)
+ {
+ if (GTK_WIDGET_SENSITIVE (children->data))
+ {
+ gtk_option_menu_set_history (option_menu, index);
+ return;
+ }
+
+ children = children->next;
+ index++;
+ }
+ }
+}
+
+static void
+gtk_option_menu_item_state_changed_cb (GtkWidget *widget,
+ GtkStateType previous_state,
+ GtkOptionMenu *option_menu)
+{
+ GtkWidget *child = GTK_BIN (option_menu)->child;
+
+ if (child && GTK_WIDGET_SENSITIVE (child) != GTK_WIDGET_IS_SENSITIVE (widget))
+ gtk_widget_set_sensitive (child, GTK_WIDGET_IS_SENSITIVE (widget));
+}
+
+static void
+gtk_option_menu_item_destroy_cb (GtkWidget *widget,
+ GtkOptionMenu *option_menu)
+{
+ GtkWidget *child = GTK_BIN (option_menu)->child;
+
+ if (child)
+ {
+ gtk_widget_ref (child);
+ gtk_option_menu_remove_contents (option_menu);
+ gtk_widget_destroy (child);
+ gtk_widget_unref (child);
+
+ gtk_option_menu_select_first_sensitive (option_menu);
+ }
+}
+
static void
gtk_option_menu_update_contents (GtkOptionMenu *option_menu)
{
child = GTK_BIN (option_menu->menu_item)->child;
if (child)
{
- if (GTK_BIN (option_menu)->child)
- gtk_container_remove (GTK_CONTAINER (option_menu),
- GTK_BIN (option_menu)->child);
- if (GTK_WIDGET (option_menu)->state != child->state)
- gtk_widget_set_state (child, GTK_WIDGET (option_menu)->state);
+ if (!GTK_WIDGET_IS_SENSITIVE (option_menu->menu_item))
+ gtk_widget_set_sensitive (child, FALSE);
gtk_widget_reparent (child, GTK_WIDGET (option_menu));
}
+ gtk_signal_connect (GTK_OBJECT (option_menu->menu_item), "state_changed",
+ GTK_SIGNAL_FUNC (gtk_option_menu_item_state_changed_cb), option_menu);
+ gtk_signal_connect (GTK_OBJECT (option_menu->menu_item), "destroy",
+ GTK_SIGNAL_FUNC (gtk_option_menu_item_destroy_cb), option_menu);
+
gtk_widget_size_request (child, &child_requisition);
gtk_widget_size_allocate (GTK_WIDGET (option_menu),
&(GTK_WIDGET (option_menu)->allocation));
static void
gtk_option_menu_remove_contents (GtkOptionMenu *option_menu)
{
+ GtkWidget *child;
+
g_return_if_fail (option_menu != NULL);
g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
- if (GTK_BIN (option_menu)->child)
+ if (option_menu->menu_item)
{
- if (GTK_WIDGET (option_menu->menu_item)->state != GTK_BIN (option_menu)->child->state)
- gtk_widget_set_state (GTK_BIN (option_menu)->child,
- GTK_WIDGET (option_menu->menu_item)->state);
- gtk_widget_reparent (GTK_BIN (option_menu)->child, option_menu->menu_item);
+ child = GTK_BIN (option_menu)->child;
+
+ if (child)
+ {
+ gtk_widget_set_sensitive (child, TRUE);
+ gtk_widget_reparent (child, option_menu->menu_item);
+ }
+
+ gtk_signal_disconnect_by_func (GTK_OBJECT (option_menu->menu_item),
+ GTK_SIGNAL_FUNC (gtk_option_menu_item_state_changed_cb),
+ option_menu);
+ gtk_signal_disconnect_by_func (GTK_OBJECT (option_menu->menu_item),
+ GTK_SIGNAL_FUNC (gtk_option_menu_item_destroy_cb),
+ option_menu);
+
gtk_widget_unref (option_menu->menu_item);
option_menu->menu_item = NULL;
}
}
}
- return FALSE;
+ return TRUE;
}
static gint
range->click_child = 0;
}
- return FALSE;
+ return TRUE;
}
static gint
}
}
- return FALSE;
+ return TRUE;
}
static gint
gtk_range_draw_step_back (range);
}
- return FALSE;
+ return TRUE;
}
static gint
gtk_range_draw_step_back (range);
}
- return FALSE;
+ return TRUE;
}
static gint
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
gtk_widget_draw_focus (widget);
- return FALSE;
+ return TRUE;
}
static gint
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
gtk_widget_draw_focus (widget);
- return FALSE;
+ return TRUE;
}
static void
#ifndef G_OS_WIN32
var = getenv("GTK_EXE_PREFIX");
if (var)
- path = g_strdup_printf("%s%s%s", var, "/lib/gtk-2.0/" GTK_VERSION "/", type);
+ path = g_strconcat (var, "/lib/gtk-2.0/" GTK_VERSION "/", type, NULL);
else
- path = g_strdup_printf("%s%s%s", GTK_EXE_PREFIX, "/lib/gtk-2.0/" GTK_VERSION "/", type);
+ path = g_strconcat (GTK_LIBDIR "/gtk-2.0/" GTK_VERSION "/", type, NULL);
#else
- path = g_strdup_printf ("%s\\%s", get_themes_directory (), type);
+ path = g_strconcat ("%s\\%s", get_themes_directory (), type);
#endif
return path;
#ifndef G_OS_WIN32
var = getenv("GTK_DATA_PREFIX");
if (var)
- path = g_strdup_printf("%s%s", var, "/share/themes");
+ path = g_strconcat (var, "/share/themes", NULL);
else
- path = g_strdup_printf("%s%s", GTK_DATA_PREFIX, "/share/themes");
+ path = g_strconcat (GTK_DATA_PREFIX, "/share/themes", NULL);
#else
path = g_strdup (get_themes_directory ());
#endif
#ifndef G_OS_WIN32
var = getenv("GTK_EXE_PREFIX");
if (var)
- path = g_strdup_printf("%s%s", var, "/lib/gtk-2.0/" GTK_VERSION "/engines");
+ path = g_strconcat(var, "/lib/gtk-2.0/" GTK_VERSION "/engines", NULL);
else
- path = g_strdup_printf("%s%s", GTK_EXE_PREFIX, "/lib/gtk-2.0/" GTK_VERSION "/engines");
+ path = g_strdup (GTK_LIBDIR "/gtk-2.0/" GTK_VERSION "/engines");
#else
- path = g_strdup_printf ("%s%s", get_themes_directory (), "\\engines");
+ path = g_strconcat (get_themes_directory (), "\\engines", NULL);
#endif
module_path[n++] = path;
else
sep = "";
/* This produces something like ~/.gtk-2.0/2.0/engines */
- path = g_strdup_printf ("%s%s%s", var, sep,
- ".gtk-2.0" G_DIR_SEPARATOR_S
- GTK_VERSION G_DIR_SEPARATOR_S
- "engines");
+ path = g_strconcat (var, sep,
+ ".gtk-2.0" G_DIR_SEPARATOR_S
+ GTK_VERSION G_DIR_SEPARATOR_S
+ "engines", NULL);
module_path[n++] = path;
}
module_path[n] = NULL;
{
GTK_STYLE_GET_CLASS (style)->unrealize (style);
+ gdk_colormap_unref (style->colormap);
+ style->colormap = NULL;
+
gtk_style_unref (style);
}
}
{
g_return_if_fail (GTK_IS_STYLE (style));
- style->colormap = colormap;
+ style->colormap = gdk_colormap_ref (colormap);
style->depth = gdk_colormap_get_visual (colormap)->depth;
GTK_STYLE_GET_CLASS (style)->realize (style);
gtk_gc_release (style->mid_gc[i]);
gtk_gc_release (style->text_gc[i]);
gtk_gc_release (style->base_gc[i]);
+
+ if (style->bg_pixmap[i] && style->bg_pixmap[i] != (GdkPixmap*) GDK_PARENT_RELATIVE)
+ gdk_pixmap_unref (style->bg_pixmap[i]);
}
+
+ gdk_colormap_free_colors (style->colormap, style->fg, 5);
+ gdk_colormap_free_colors (style->colormap, style->bg, 5);
+ gdk_colormap_free_colors (style->colormap, style->light, 5);
+ gdk_colormap_free_colors (style->colormap, style->dark, 5);
+ gdk_colormap_free_colors (style->colormap, style->mid, 5);
+ gdk_colormap_free_colors (style->colormap, style->text, 5);
+ gdk_colormap_free_colors (style->colormap, style->base, 5);
}
static void
clear_focus_area (GtkText *text, gint area_x, gint area_y, gint area_width, gint area_height)
{
GtkWidget *widget = GTK_WIDGET (text);
-
+ GdkGC *gc;
+
gint ythick = TEXT_BORDER_ROOM + widget->style->ythickness;
gint xthick = TEXT_BORDER_ROOM + widget->style->xthickness;
gint width, height;
- gdk_window_get_size (widget->style->bg_pixmap[GTK_STATE_NORMAL], &width, &height);
+ if (area_width == 0 || area_height == 0)
+ return;
+
+ if (widget->style->bg_pixmap[GTK_STATE_NORMAL])
+ {
+ gdk_window_get_size (widget->style->bg_pixmap[GTK_STATE_NORMAL], &width, &height);
- gdk_gc_set_ts_origin (text->bg_gc,
- (- text->first_onscreen_hor_pixel + xthick) % width,
- (- text->first_onscreen_ver_pixel + ythick) % height);
+ gdk_gc_set_ts_origin (text->bg_gc,
+ (- text->first_onscreen_hor_pixel + xthick) % width,
+ (- text->first_onscreen_ver_pixel + ythick) % height);
+
+ gc = text->bg_gc;
+ }
+ else
+ gc = widget->style->bg_gc[widget->state];
- gdk_draw_rectangle (GTK_WIDGET (text)->window, text->bg_gc, TRUE,
+ gdk_draw_rectangle (GTK_WIDGET (text)->window, gc, TRUE,
area_x, area_y, area_width, area_height);
}
width -= 2 * xthick;
height -= 2 * ythick;
- if (widget->style->bg_pixmap[GTK_STATE_NORMAL])
- {
- /* top rect */
- clear_focus_area (text, x, y, width, yextra);
- /* left rect */
- clear_focus_area (text, x, y + yextra,
- xextra, y + height - 2 * yextra);
- /* right rect */
- clear_focus_area (text, x + width - xextra, y + yextra,
- xextra, height - 2 * ythick);
- /* bottom rect */
- clear_focus_area (text, x, x + height - yextra, width, yextra);
- }
+ /* top rect */
+ clear_focus_area (text, x, y, width, yextra);
+ /* left rect */
+ clear_focus_area (text, x, y + yextra,
+ xextra, y + height - 2 * yextra);
+ /* right rect */
+ clear_focus_area (text, x + width - xextra, y + yextra,
+ xextra, height - 2 * ythick);
+ /* bottom rect */
+ clear_focus_area (text, x, x + height - yextra, width, yextra);
}
else
{
event.window = window->focus_widget->window;
event.in = TRUE;
- if (window->default_widget)
- {
- if (GTK_WIDGET_RECEIVES_DEFAULT (window->focus_widget) &&
- (window->focus_widget != window->default_widget))
- {
- if (GTK_WIDGET_CAN_DEFAULT (window->focus_widget))
- GTK_WIDGET_SET_FLAGS (window->focus_widget, GTK_HAS_DEFAULT);
- GTK_WIDGET_UNSET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
- }
- else
- {
- GTK_WIDGET_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
- }
+ if (GTK_WIDGET_RECEIVES_DEFAULT (window->focus_widget) &&
+ (window->focus_widget != window->default_widget))
+ {
+ if (GTK_WIDGET_CAN_DEFAULT (window->focus_widget))
+ GTK_WIDGET_SET_FLAGS (window->focus_widget, GTK_HAS_DEFAULT);
+
+ if (window->default_widget)
+ GTK_WIDGET_UNSET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
}
gtk_widget_event (window->focus_widget, (GdkEvent*) &event);
}
- else if (window->default_widget)
- {
- GTK_WIDGET_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
- }
if (window->default_widget &&
(def_flags != GTK_WIDGET_FLAGS (window->default_widget)))
{ "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
{ "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
{ "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
+ { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
+ { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
+
+ /* For testing deletion of menus */
+ { "/_Preferences/Should_NotAppear", NULL, 0, 0, "<Branch>" },
+ { "/Preferences/ShouldNotAppear/SubItem1", NULL, gtk_ifactory_cb, 0 },
+ { "/Preferences/ShouldNotAppear/SubItem2", NULL, gtk_ifactory_cb, 0 },
{ "/_Help", NULL, 0, 0, "<LastBranch>" },
{ "/Help/_About", NULL, gtk_ifactory_cb, 0 },
};
+
static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
static void
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
+ gtk_item_factory_delete_item (item_factory, "/Preferences/ShouldNotAppear");
+
gtk_widget_show_all (window);
}
else
{ "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
{ "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
{ "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
+ { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
+ { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
+
+ /* For testing deletion of menus */
+ { "/_Preferences/Should_NotAppear", NULL, 0, 0, "<Branch>" },
+ { "/Preferences/ShouldNotAppear/SubItem1", NULL, gtk_ifactory_cb, 0 },
+ { "/Preferences/ShouldNotAppear/SubItem2", NULL, gtk_ifactory_cb, 0 },
{ "/_Help", NULL, 0, 0, "<LastBranch>" },
{ "/Help/_About", NULL, gtk_ifactory_cb, 0 },
};
+
static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
static void
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
+ gtk_item_factory_delete_item (item_factory, "/Preferences/ShouldNotAppear");
+
gtk_widget_show_all (window);
}
else
projects / gtk4.git / commitdiff